// 版权所有2009 Go作者。保留所有权利。
// 此源代码的使用受BSD样式
// 许可证的约束，该许可证可以在许可证文件中找到。

package http

import (
	"bufio"
	"bytes"
	"errors"
	"fmt"
	"io"
	"net/http/httptrace"
	"net/http/internal"
	"net/http/internal/ascii"
	"net/textproto"
	"reflect"
	"sort"
	"strconv"
	"strings"
	"sync"
	"time"

	"golang.org/x/net/http/httpguts"
)

// ErrLineTooLong在读取格式错误的分块编码的请求或响应正文
// 时返回。
var ErrLineTooLong = internal.ErrLineTooLong

type errorReader struct {
	err error
}

func (r errorReader) Read(p []byte) (n int, err error) {
	return 0, r.err
}

type byteReader struct {
	b    byte
	done bool
}

func (br *byteReader) Read(p []byte) (n int, err error) {
	if br.done {
		return 0, io.EOF
	}
	if len(p) == 0 {
		return 0, nil
	}
	br.done = true
	p[0] = br.b
	return 1, io.EOF
}

// transferWriter检查用户提供的请求或响应的字段，
// 在不更改用户对象的情况下对这些字段进行清理，并提供方法用于
// 以有线格式写入相应的头、体和尾。
type transferWriter struct {
	Method           string
	Body             io.Reader
	BodyCloser       io.Closer
	ResponseToHEAD   bool
	ContentLength    int64 // /-1表示未知，0表示完全无
	Close            bool
	TransferEncoding []string
	Header           Header
	Trailer          Header
	IsResponse       bool
	bodyReadError    error // 读取主体

	FlushHeaders bool            // 在主体
	ByteReadCh   chan readResult // 之前将头刷新到网络
}

func newTransferWriter(r any) (t *transferWriter, err error) {
	t = &transferWriter{}

	// 提取相关字段
	atLeastHTTP11 := false
	switch rr := r.(type) {
	case *Request:
		if rr.ContentLength != 0 && rr.Body == nil {
			return nil, fmt.Errorf("http: Request.ContentLength=%d with nil Body", rr.ContentLength)
		}
		t.Method = valueOrDefault(rr.Method, "GET")
		t.Close = rr.Close
		t.TransferEncoding = rr.TransferEncoding
		t.Header = rr.Header
		t.Trailer = rr.Trailer
		t.Body = rr.Body
		t.BodyCloser = rr.Body
		t.ContentLength = rr.outgoingLength()
		if t.ContentLength < 0 && len(t.TransferEncoding) == 0 && t.shouldSendChunkedRequestBody() {
			t.TransferEncoding = []string{"chunked"}
		}
		// 如果有主体，保守地将头
		// 刷新到任何bufio。我们正在写信给的作者，以防万一在我们复制主体和可能的块之前，服务器需要提前获得标题。我们对内存类型中的通用标准库
		// 做了一个例外，以避免在
		// 线路上出现不必要的TCP数据包。（第22088期）
		if t.ContentLength != 0 && !isKnownInMemoryReader(t.Body) {
			t.FlushHeaders = true
		}

		atLeastHTTP11 = true // 传输请求始终为1.1或2.0 
	case *Response:
		t.IsResponse = true
		if rr.Request != nil {
			t.Method = rr.Request.Method
		}
		t.Body = rr.Body
		t.BodyCloser = rr.Body
		t.ContentLength = rr.ContentLength
		t.Close = rr.Close
		t.TransferEncoding = rr.TransferEncoding
		t.Header = rr.Header
		t.Trailer = rr.Trailer
		atLeastHTTP11 = rr.ProtoAtLeast(1, 1)
		t.ResponseToHEAD = noResponseBodyExpected(t.Method)
	}

	// 清理正文、内容长度、传输编码
	if t.ResponseToHEAD {
		t.Body = nil
		if chunked(t.TransferEncoding) {
			t.ContentLength = -1
		}
	} else {
		if !atLeastHTTP11 || t.Body == nil {
			t.TransferEncoding = nil
		}
		if chunked(t.TransferEncoding) {
			t.ContentLength = -1
		} else if t.Body == nil { // 无分块、无正文
			t.ContentLength = 0
		}
	}

	// 清理尾部
	if !chunked(t.TransferEncoding) {
		t.Trailer = nil
	}

	return t, nil
}

// 应发送分块请求正文报告我们是否应尝试向服务器发送
// 分块请求正文。特别是，我们真正想要防止的情况是，当正文为零字节时，向带有分块正文的
// 服务器发送GET或其他典型的无正文请求，因为带有
// 正文的GET（虽然根据规范可以接受），即使是零字节分块的
// 正文，它们几乎从未在野外出现过，让大多数
// 服务器感到困惑。例如，见第18257期。
// 
// 我们发送此类请求的唯一原因是，如果用户将正文设置为
// 非零值（例如，io.nocloser（bytes.NewReader（nil）），并且没有设置ContentLength，或者NewRequest将其设置为-1（未知），那么我们假设
// 有字节要发送。
// 
// 此代码尝试从请求中读取一个字节。在这种情况下，Body可以查看
// 该Body是否真的有内容（非常罕见）或实际上只是
// 非零内容更少的ReadCloser（更常见的情况）。在更常见的情况下，我们的行为就像他们的身体是零，而不是发送一个身体。
func (t *transferWriter) shouldSendChunkedRequestBody() bool {
	// 请注意，t.ContentLength是rr中更正的内容长度
	// 。所以0实际上意味着零，不是未知的。
	if t.ContentLength >= 0 || t.Body == nil { // 冗余检查；打电话的人告诉他们
		return false
	}
	if t.Method == "CONNECT" {
		return false
	}
	if requestMethodUsuallyLacksBody(t.Method) {
		// 只探测请求。GET/HEAD/DELETE/etc 
		// 请求的主体，因为只有那些类型的请求
		// 会让服务器感到困惑。
		t.probeRequestBody() // 调整t.Body、t.ContentLength 
		return t.Body != nil
	}
	// 所有其他请求类型（PUT、POST、PATCH或任何我们从未听说过的
	// 组合），假设这是正常的，服务器
	// 可以处理分块的请求体。也许我们以后会调整这个
	// 。
	return true
}

// probeRequestBody从t.Body读取一个字节，查看它是否为空
// （立即返回io.EOF）。
// 
// 但由于我们在过去的
// （17480期）中遇到了阻止用户的问题，当主体是管道时（可能在管道输入数据之前等待响应
// 头），我们需要小心并限制
// 我们要等待多长时间。此延迟仅在以下所有
// /均为真时才会影响用户：
// /*请求正文阻止
// /*内容长度未设置（或设置为-1）
// /*该方法通常没有正文（GET、HEAD、DELETE等）
// /*没有传输编码=已设置分块。换句话说，这个延迟通常不会影响任何人，如果它影响到了，那么这里有一些变通办法。
func (t *transferWriter) probeRequestBody() {
	t.ByteReadCh = make(chan readResult, 1)
	go func(body io.Reader) {
		var buf [1]byte
		var rres readResult
		rres.n, rres.err = body.Read(buf[:])
		if rres.n == 1 {
			rres.b = buf[0]
		}
		t.ByteReadCh <- rres
		close(t.ByteReadCh)
	}(t.Body)
	timer := time.NewTimer(200 * time.Millisecond)
	select {
	case rres := <-t.ByteReadCh:
		timer.Stop()
		if rres.n == 0 && rres.err == io.EOF {
			// 它是空的。
			t.Body = nil
			t.ContentLength = 0
		} else if rres.n == 1 {
			if rres.err != nil {
				t.Body = io.MultiReader(&byteReader{b: rres.b}, errorReader{rres.err})
			} else {
				t.Body = io.MultiReader(&byteReader{b: rres.b}, t.Body)
			}
		} else if rres.err != nil {
			t.Body = errorReader{rres.err}
		}
	case <-timer.C:
		// 太慢了。别等了。稍后阅读，并保持
		// 假设这是ContentLength=-1 
		// （未知），这意味着我们将发送一个
		// “传输编码：分块”头。
		t.Body = io.MultiReader(finishAsyncByteRead{t}, t.Body)
		// 请求那个请求。将标题写入
		// 在写正文之前先上网，因为我们的正文在看到响应头之前可能不可读。
		t.FlushHeaders = true
	}
}

func noResponseBodyExpected(requestMethod string) bool {
	return requestMethod == "HEAD"
}

func (t *transferWriter) shouldSendContentLength() bool {
	if chunked(t.TransferEncoding) {
		return false
	}
	if t.ContentLength > 0 {
		return true
	}
	if t.ContentLength < 0 {
		return false
	}
	// 许多服务器期望这些方法的内容长度
	if t.Method == "POST" || t.Method == "PUT" || t.Method == "PATCH" {
		return true
	}
	if t.ContentLength == 0 && isIdentity(t.TransferEncoding) {
		if t.Method == "GET" || t.Method == "HEAD" {
			return false
		}
		return true
	}

	return false
}

func (t *transferWriter) writeHeader(w io.Writer, trace *httptrace.ClientTrace) error {
	if t.Close && !hasToken(t.Header.get("Connection"), "close") {
		if _, err := io.WriteString(w, "Connection: close\r\n"); err != nil {
			return err
		}
		if trace != nil && trace.WroteHeaderField != nil {
			trace.WroteHeaderField("Connection", []string{"close"})
		}
	}

	// 写入内容长度和/或传输编码，其值为
	// 净化字段三元组的函数（Body，ContentLength，
	// transferncoding）
	if t.shouldSendContentLength() {
		if _, err := io.WriteString(w, "Content-Length: "); err != nil {
			return err
		}
		if _, err := io.WriteString(w, strconv.FormatInt(t.ContentLength, 10)+"\r\n"); err != nil {
			return err
		}
		if trace != nil && trace.WroteHeaderField != nil {
			trace.WroteHeaderField("Content-Length", []string{strconv.FormatInt(t.ContentLength, 10)})
		}
	} else if chunked(t.TransferEncoding) {
		if _, err := io.WriteString(w, "Transfer-Encoding: chunked\r\n"); err != nil {
			return err
		}
		if trace != nil && trace.WroteHeaderField != nil {
			trace.WroteHeaderField("Transfer-Encoding", []string{"chunked"})
		}
	}

	// 写入尾部头
	if t.Trailer != nil {
		keys := make([]string, 0, len(t.Trailer))
		for k := range t.Trailer {
			k = CanonicalHeaderKey(k)
			switch k {
			case "Transfer-Encoding", "Trailer", "Content-Length":
				return badStringError("invalid Trailer key", k)
			}
			keys = append(keys, k)
		}
		if len(keys) > 0 {
			sort.Strings(keys)
			// TODO:在这里可以更好地分配，但是预告片很少见，所以现在很懒。
			if _, err := io.WriteString(w, "Trailer: "+strings.Join(keys, ",")+"\r\n"); err != nil {
				return err
			}
			if trace != nil && trace.WroteHeaderField != nil {
				trace.WroteHeaderField("Trailer", keys)
			}
		}
	}

	return nil
}

// 始终关闭t.BodyCloser 
func (t *transferWriter) writeBody(w io.Writer) (err error) {
	var ncopy int64
	closed := false
	defer func() {
		if closed || t.BodyCloser == nil {
			return
		}
		if closeErr := t.BodyCloser.Close(); closeErr != nil && err == nil {
			err = closeErr
		}
	}()

	// 写入正文。如果尸体被包裹在
	// NoCloser或readTrackingBody中，我们首先“打开”尸体。这是为了确保我们可以利用
	// /*操作系统级别的优化，以防主体是
	// /*操作系统。文件
	if t.Body != nil {
		var body = t.unwrapBody()
		if chunked(t.TransferEncoding) {
			if bw, ok := w.(*bufio.Writer); ok && !t.IsResponse {
				w = &internal.FlushAfterChunkWriter{Writer: bw}
			}
			cw := internal.NewChunkedWriter(w)
			_, err = t.doBodyCopy(cw, body)
			if err == nil {
				err = cw.Close()
			}
		} else if t.ContentLength == -1 {
			dst := w
			if t.Method == "CONNECT" {
				dst = bufioFlushWriter{dst}
			}
			ncopy, err = t.doBodyCopy(dst, body)
		} else {
			ncopy, err = t.doBodyCopy(w, io.LimitReader(body, t.ContentLength))
			if err != nil {
				return err
			}
			var nextra int64
			nextra, err = t.doBodyCopy(io.Discard, body)
			ncopy += nextra
		}
		if err != nil {
			return err
		}
	}
	if t.BodyCloser != nil {
		closed = true
		if err := t.BodyCloser.Close(); err != nil {
			return err
		}
	}

	if !t.ResponseToHEAD && t.ContentLength != -1 && t.ContentLength != ncopy {
		return fmt.Errorf("http: ContentLength=%d with Body length %d",
			t.ContentLength, ncopy)
	}

	if chunked(t.TransferEncoding) {
		// 写入尾部头
		if t.Trailer != nil {
			if err := t.Trailer.Write(w); err != nil {
				return err
			}
		}
		// 最后一个块，空尾部
		_, err = io.WriteString(w, "\r\n")
	}
	return err
}

// doBodyCopy包装一个复制操作，产生的任何错误也将保存在bodyReadError中。
// 
// 此函数仅用于写库。
func (t *transferWriter) doBodyCopy(dst io.Writer, src io.Reader) (n int64, err error) {
	n, err = io.Copy(dst, src)
	if err != nil && err != io.EOF {
		t.bodyReadError = err
	}
	return
}

// unwrapBodyReader如果是
// NoCloser，则打开身体的内部读取器。这是为了确保源于本地
// 文件（*os.File type）的正文写入得到适当优化。
// 
// 此函数仅用于写库。
func (t *transferWriter) unwrapBody() io.Reader {
	if reflect.TypeOf(t.Body) == nopCloserType {
		return reflect.ValueOf(t.Body).Field(0).Interface().(io.Reader)
	}
	if r, ok := t.Body.(*readTrackingBody); ok {
		r.didRead = true
		return r.ReadCloser
	}
	return t.Body
}

type transferReader struct {
	// 输入
	Header        Header
	StatusCode    int
	RequestMethod string
	ProtoMajor    int
	ProtoMinor    int
	// 输出
	Body          io.ReadCloser
	ContentLength int64
	Chunked       bool
	Close         bool
	Trailer       Header
}

func (t *transferReader) protoAtLeast(m, n int) bool {
	return t.ProtoMajor > m || (t.ProtoMajor == m && t.ProtoMinor >= n)
}

// bodyAllowedForStatus报告给定的响应状态代码
// 是否允许正文。参见RFC 7230，第3.3节。
func bodyAllowedForStatus(status int) bool {
	switch {
	case status >= 100 && status <= 199:
		return false
	case status == 204:
		return false
	case status == 304:
		return false
	}
	return true
}

var (
	suppressedHeaders304    = []string{"Content-Type", "Content-Length", "Transfer-Encoding"}
	suppressedHeadersNoBody = []string{"Content-Length", "Transfer-Encoding"}
)

func suppressedHeaders(status int) []string {
	switch {
	case status == 304:
		// RFC 7232第4.1节
		return suppressedHeaders304
	case !bodyAllowedForStatus(status):
		return suppressedHeadersNoBody
	}
	return nil
}

// msg是*请求还是*响应。
func readTransfer(msg any, r *bufio.Reader) (err error) {
	t := &transferReader{RequestMethod: "GET"}

	// 统一输入
	isResponse := false
	switch rr := msg.(type) {
	case *Response:
		t.Header = rr.Header
		t.StatusCode = rr.StatusCode
		t.ProtoMajor = rr.ProtoMajor
		t.ProtoMinor = rr.ProtoMinor
		t.Close = shouldClose(t.ProtoMajor, t.ProtoMinor, t.Header, true)
		isResponse = true
		if rr.Request != nil {
			t.RequestMethod = rr.Request.Method
		}
	case *Request:
		t.Header = rr.Header
		t.RequestMethod = rr.Method
		t.ProtoMajor = rr.ProtoMajor
		t.ProtoMinor = rr.ProtoMinor
		// 请求的传输语义与
		// 状态码为200的响应，响应GET方法
		t.StatusCode = 200
		t.Close = rr.Close
	default:
		panic("unexpected type")
	}

	// 默认为HTTP/1.1 
	if t.ProtoMajor == 0 && t.ProtoMinor == 0 {
		t.ProtoMajor, t.ProtoMinor = 1, 1
	}

	// 传输编码：分块，覆盖内容长度。
	if err := t.parseTransferEncoding(); err != nil {
		return err
	}

	realLength, err := fixLength(isResponse, t.StatusCode, t.RequestMethod, t.Header, t.Chunked)
	if err != nil {
		return err
	}
	if isResponse && t.RequestMethod == "HEAD" {
		if n, err := parseContentLength(t.Header.get("Content-Length")); err != nil {
			return err
		} else {
			t.ContentLength = n
		}
	} else {
		t.ContentLength = realLength
	}

	// 预告片
	t.Trailer, err = fixTrailer(t.Header, t.Chunked)
	if err != nil {
		return err
	}

	// 如果*响应
	// 上没有内容长度或分块传输编码，并且状态不是1x、204或304，则正文是无限制的。
	// 参见RFC 7230第3.3节。
	switch msg.(type) {
	case *Response:
		if realLength == -1 && !t.Chunked && bodyAllowedForStatus(t.StatusCode) {
			// 无限体。
			t.Close = true
		}
	}

	// 准备身体读取器。ContentLength<0表示分块编码
	// 或完成后关闭连接，因为目前还不支持多部分
	switch {
	case t.Chunked:
		if noResponseBodyExpected(t.RequestMethod) || !bodyAllowedForStatus(t.StatusCode) {
			t.Body = NoBody
		} else {
			t.Body = &body{src: internal.NewChunkedReader(r), hdr: msg, r: r, closing: t.Close}
		}
	case realLength == 0:
		t.Body = NoBody
	case realLength > 0:
		t.Body = &body{src: io.LimitReader(r, realLength), closing: t.Close}
	default:
		// realLength<0，例如，标题中未提及的“内容长度”
		if t.Close {
			// 关闭语义（即HTTP/1.0）
			t.Body = &body{src: r, closing: t.Close}
		} else {
			// 持久连接（即HTTP/1.1）
			t.Body = NoBody
		}
	}

	// 统一输出
	switch rr := msg.(type) {
	case *Request:
		rr.Body = t.Body
		rr.ContentLength = t.ContentLength
		if t.Chunked {
			rr.TransferEncoding = []string{"chunked"}
		}
		rr.Close = t.Close
		rr.Trailer = t.Trailer
	case *Response:
		rr.Body = t.Body
		rr.ContentLength = t.ContentLength
		if t.Chunked {
			rr.TransferEncoding = []string{"chunked"}
		}
		rr.Close = t.Close
		rr.Trailer = t.Trailer
	}

	return nil
}

// 检查分块是否是编码堆栈的一部分
func chunked(te []string) bool { return len(te) > 0 && te[0] == "chunked" }

// 检查编码是否显式“标识”。
func isIdentity(te []string) bool { return len(te) == 1 && te[0] == "identity" }

// unsupportedTEError报告不支持的传输编码。
type unsupportedTEError struct {
	err string
}

func (uste *unsupportedTEError) Error() string {
	return uste.err
}

// isUnsupportedTEError检查错误类型是否为
// unsupportedTEError。它通常用非nil err调用。
func isUnsupportedTEError(err error) bool {
	_, ok := err.(*unsupportedTEError)
	return ok
}

// parseTransferEncoding集合t。根据传输编码头分块。
func (t *transferReader) parseTransferEncoding() error {
	raw, present := t.Header["Transfer-Encoding"]
	if !present {
		return nil
	}
	delete(t.Header, "Transfer-Encoding")

	// 第12785期；忽略HTTP/1.0请求上的传输编码。
	if !t.protoAtLeast(1, 1) {
		return nil
	}

	// 与nginx一样，我们只支持单个传输编码头字段，而
	// 仅当设置为“chunked”时才支持。由于存在请求走私的风险，这是HTTP/1.1中对安全最敏感的
	// 表面之一，因此我们将其保持为
	// 严格而简单。
	if len(raw) != 1 {
		return &unsupportedTEError{fmt.Sprintf("too many transfer encodings: %q", raw)}
	}
	if !ascii.EqualFold(textproto.TrimString(raw[0]), "chunked") {
		return &unsupportedTEError{fmt.Sprintf("unsupported transfer encoding: %q", raw[0])}
	}

	// RFC 7230 3.3.2规定，“发件人不得在任何包含传输编码头字段的邮件中发送内容长度头字段
	// 。”
	// 
	// 但是：“如果收到的消息同时带有传输编码和
	// 内容长度头字段，则传输编码将覆盖
	// 内容长度。这样的消息可能表示有人试图执行
	// 请求走私（第9.5节）或响应拆分（第9.4节）而
	// 应该作为错误处理。在向下游转发此类消息之前，发送方必须删除收到的
	// 内容长度字段。“
	// 
	// 据报道，它们出现在野外。
	delete(t.Header, "Content-Length")

	t.Chunked = true
	return nil
}

// 使用RFC 7230第3.3节确定预期的体长。这个
// 函数不是一个方法，因为它最终应该由
// ReadResponse和ReadRequest共享。
func fixLength(isResponse bool, status int, requestMethod string, header Header, chunked bool) (int64, error) {
	isRequest := !isResponse
	contentLens := header["Content-Length"]

	// 加强对HTTP请求走私的防范
	if len(contentLens) > 1 {
		// 每RFC 7230第3.3.2节，防止多重
		// 内容长度标题，如果它们的值不同。
		// 如果存在该值的DUP，请删除DUP。
		// 见第16490期。
		first := textproto.TrimString(contentLens[0])
		for _, ct := range contentLens[1:] {
			if first != textproto.TrimString(ct) {
				return 0, fmt.Errorf("http: message cannot contain multiple Content-Length headers; got %q", contentLens)
			}
		}

		// 重复数据消除内容长度
		header.Del("Content-Length")
		header.Add("Content-Length", first)

		contentLens = header["Content-Length"]
	}

	// 基于响应类型或状态的逻辑
	if noResponseBodyExpected(requestMethod) {
		// 对于HTTP请求，作为对请求进行强化的一部分
		// 走私（RFC 7230），不允许对不允许正文的
		// 方法使用内容长度头。作为例外，如果值为“0”，则允许
		// 正好有一个内容长度头。
		if isRequest && len(contentLens) > 0 && !(len(contentLens) == 1 && contentLens[0] == "0") {
			return 0, fmt.Errorf("http: method cannot contain a Content-Length; got %q", contentLens)
		}
		return 0, nil
	}
	if status/100 == 1 {
		return 0, nil
	}
	switch status {
	case 204, 304:
		return 0, nil
	}

	// 基于传输编码的逻辑
	if chunked {
		return -1, nil
	}

	// 基于内容长度的逻辑
	var cl string
	if len(contentLens) == 1 {
		cl = textproto.TrimString(contentLens[0])
	}
	if cl != "" {
		n, err := parseContentLength(cl)
		if err != nil {
			return -1, err
		}
		return n, nil
	}
	header.Del("Content-Length")

	if isRequest {
		// RFC 7230既不明确允许也不禁止GET请求中的
		// 实体体，因此如果声明了
		// 我们就允许一个，但如果没有提到实体，我们在这里默认为0（不是下面的-1）。
		// 同样，如果未设置传输编码分块或
		// 内容长度，则假定所有其他请求方法都没有正文。
		return 0, nil
	}

	// 基于其他方法（如关闭或分块编码）的逻辑体EOF 
	return -1, nil
}

// 在发送请求和正文后确定是否挂断，或者
// 接收响应和正文
// ‘header’是请求头
func shouldClose(major, minor int, header Header, removeCloseHeader bool) bool {
	if major < 1 {
		return true
	}

	conv := header["Connection"]
	hasClose := httpguts.HeaderValuesContainsToken(conv, "close")
	if major == 1 && minor == 0 {
		return hasClose || !httpguts.HeaderValuesContainsToken(conv, "keep-alive")
	}

	if hasClose && removeCloseHeader {
		header.Del("Connection")
	}

	return hasClose
}

// 解析尾部头部
func fixTrailer(header Header, chunked bool) (Header, error) {
	vv, ok := header["Trailer"]
	if !ok {
		return nil, nil
	}
	if !chunked {
		// 尾部和无分块：
		// 这是尾部头部的无效用例。
		// 然而，不会返回任何错误，我们
		// 让用户决定这是否是有效的HTTP消息。
		// 拖车头将保留作为响应。标题
		// 但不填充响应。拖车
		// 见第27197期。
		return nil, nil
	}
	header.Del("Trailer")

	trailer := make(Header)
	var err error
	for _, v := range vv {
		foreachHeaderElement(v, func(key string) {
			key = CanonicalHeaderKey(key)
			switch key {
			case "Transfer-Encoding", "Trailer", "Content-Length":
				if err == nil {
					err = badStringError("bad trailer key", key)
					return
				}
			}
			trailer[key] = nil
		})
	}
	if err != nil {
		return nil, err
	}
	if len(trailer) == 0 {
		return nil, nil
	}
	return trailer, nil
}

// body将一个阅读器变成了一个读卡器。
// Close确保主体已被完全读取
// 然后在必要时读取预告片。
type body struct {
	src          io.Reader
	hdr          any           // 非零（响应或请求）值表示已读预告片
	r            *bufio.Reader // 预告片的底层有线格式读取器
	closing      bool          // 读取正文后是否关闭连接？
	doEarlyClose bool          // Close是否应该提前停止

	mu         sync.Mutex // 警卫跟随，并呼叫读取和关闭
	sawEOF     bool
	closed     bool
	earlyClose bool   // Close呼叫，我们没有读取到src 
	onHitEOF   func() // 如果非零，读取EOF时调用的函数
}

// ErrBodyReadAfterClose在主体关闭后读取请求或响应
// Body时返回。这通常发生在HTTP处理程序调用WriteHeader或在其
// read时。
// ResponseWriter上写入后，正文为
var ErrBodyReadAfterClose = errors.New("http: invalid Read on closed Body")

func (b *body) Read(p []byte) (n int, err error) {
	b.mu.Lock()
	defer b.mu.Unlock()
	if b.closed {
		return 0, ErrBodyReadAfterClose
	}
	return b.readLocked(p)
}

// 必须持有b.mu。
func (b *body) readLocked(p []byte) (n int, err error) {
	if b.sawEOF {
		return 0, io.EOF
	}
	n, err = b.src.Read(p)

	if err == io.EOF {
		b.sawEOF = true
		// 分块案例。看预告片。
		if b.hdr != nil {
			if e := b.readTrailer(); e != nil {
				err = e
				// 预告片中出现了问题，我们不能允许任何
				// 从body进一步读取任何类型的内容，也不能允许任何
				// 服务器连接上的后续请求。参见
				// golang。org/issue/12027 
				b.sawEOF = false
				b.closed = true
			}
			b.hdr = nil
		} else {
			// 如果服务器声明了内容长度，我们的身体是有限的领导者
			// 我们需要检查此EOF是否提前到达。
			if lr, ok := b.src.(*io.LimitedReader); ok && lr.N > 0 {
				err = io.ErrUnexpectedEOF
			}
		}
	}

	// 如果我们可以在这里返回一个EOF和读取的数据，请执行
	// 这样做。根据io，这是可选的。读卡器契约，但执行
	// 这样做有助于HTTP传输代码在更早的时候回收其连接
	// 因为它会看到自己的EOF，即使
	// 客户端将来不执行读取或关闭操作。
	if err == nil && n > 0 {
		if lr, ok := b.src.(*io.LimitedReader); ok && lr.N == 0 {
			err = io.EOF
			b.sawEOF = true
		}
	}

	if b.sawEOF && b.onHitEOF != nil {
		b.onHitEOF()
	}

	return n, err
}

var (
	singleCRLF = []byte("\r\n")
	doubleCRLF = []byte("\r\n\r\n")
)

func seeUpcomingDoubleCRLF(r *bufio.Reader) bool {
	for peekSize := 4; ; peekSize++ {
		// 当Peek返回错误时，该循环停止，
		// 当r的缓冲区被填满时，该循环停止。
		buf, err := r.Peek(peekSize)
		if bytes.HasSuffix(buf, doubleCRLF) {
			return true
		}
		if err != nil {
			break
		}
	}
	return false
}

var errTrailerEOF = errors.New("http: unexpected EOF reading trailer")

func (b *body) readTrailer() error {
	// 这是常见的情况，因为没有人使用拖车。
	buf, err := b.r.Peek(2)
	if bytes.Equal(buf, singleCRLF) {
		b.r.Discard(2)
		return nil
	}
	if len(buf) < 2 {
		return errTrailerEOF
	}
	if err != nil {
		return err
	}

	// 确保即将出现标题终止符，以防止带有无限大小预告片的DoS。在这里插入LimitReader并不是一件容易的事，比如textproto。NewReader需要
	// 一个具体的*bufio。读者而且，我们不能一路支持我们康涅狄格有限公司的领导人，他们可能会支持我们的公司。读者取而代之的是一个黑客：我们反复向bufio窥视
	// 。读卡器的最大尺寸，寻找双CRLF。
	// 这将尾部限制为基础缓冲区大小，通常为4kB。返回未读输入的字节数。
	if !seeUpcomingDoubleCRLF(b.r) {
		return errors.New("http: suspiciously long trailer after chunked body")
	}

	hdr, err := textproto.NewReader(b.r).ReadMIMEHeader()
	if err != nil {
		if err == io.EOF {
			return errTrailerEOF
		}
		return err
	}
	switch rr := b.hdr.(type) {
	case *Request:
		mergeSetHeader(&rr.Trailer, Header(hdr))
	case *Response:
		mergeSetHeader(&rr.Trailer, Header(hdr))
	}
	return nil
}

func mergeSetHeader(dst *Header, src Header) {
	if *dst == nil {
		*dst = src
		return
	}
	for k, vv := range src {
		(*dst)[k] = vv
	}
}

// 如果未知，则返回-1。
// b.mu必须持有。
func (b *body) unreadDataSizeLocked() int64 {
	if lr, ok := b.src.(*io.LimitedReader); ok {
		return lr.N
	}
	return -1
}

func (b *body) Close() error {
	b.mu.Lock()
	defer b.mu.Unlock()
	if b.closed {
		return nil
	}
	var err error
	switch {
	case b.sawEOF:
		// 已经看到了EOF，所以不需要去寻找它。
	case b.hdr == nil && b.closing:
		// 没有拖车，接下来关闭连接。
		// 阅读EOF没有意义。
	case b.doEarlyClose:
		// 读取正文的maxPostHandlerReadBytes字节，查看
		// 查看EOF（和预告片），因此我们可以重新使用此连接。
		if lr, ok := b.src.(*io.LimitedReader); ok && lr.N > maxPostHandlerReadBytes {
			// 有一个声明的内容长度，我们剩余的字节数
			// 比我们的maxPostHandlerReadBytes容差多。所以，放弃吧。
			b.earlyClose = true
		} else {
			var n int64
			// 消耗身体，或者，这也将导致我们阅读
			// 身体后面的拖车标题（如果存在）。
			n, err = io.CopyN(io.Discard, bodyLocked{b}, maxPostHandlerReadBytes)
			if err == io.EOF {
				err = nil
			}
			if n == maxPostHandlerReadBytes {
				b.earlyClose = true
			}
		}
	default:
		// 完全消耗车身，这也将导致我们阅读
		// 车身后面的拖车标题（如果存在）。
		_, err = io.Copy(io.Discard, bodyLocked{b})
	}
	b.closed = true
	return err
}

func (b *body) didEarlyClose() bool {
	b.mu.Lock()
	defer b.mu.Unlock()
	return b.earlyClose
}

// BodyResistes报告未来的读取调用是否可能产生数据。
func (b *body) bodyRemains() bool {
	b.mu.Lock()
	defer b.mu.Unlock()
	return !b.sawEOF
}

func (b *body) registerOnHitEOF(fn func()) {
	b.mu.Lock()
	defer b.mu.Unlock()
	b.onHitEOF = fn
}

// bodyLocked是一个io。当*体的互斥体为
// 时，读卡器从*体读取数据。
type bodyLocked struct {
	b *body
}

func (bl bodyLocked) Read(p []byte) (n int, err error) {
	if bl.b.closed {
		return 0, ErrBodyReadAfterClose
	}
	return bl.b.readLocked(p)
}

// 如果未设置值
// 则parseContentLength从s中删除空格并返回-1，如果大于等于0，则返回值。
func parseContentLength(cl string) (int64, error) {
	cl = textproto.TrimString(cl)
	if cl == "" {
		return -1, nil
	}
	n, err := strconv.ParseUint(cl, 10, 63)
	if err != nil {
		return 0, badStringError("bad Content-Length", cl)
	}
	return int64(n), nil

}

// finishAsyncByteRead完成从ContentLength==0的正文中读取1字节嗅探
// =无案件。
type finishAsyncByteRead struct {
	tw *transferWriter
}

func (fr finishAsyncByteRead) Read(p []byte) (n int, err error) {
	if len(p) == 0 {
		return
	}
	rres := <-fr.tw.ByteReadCh
	n, err = rres.n, rres.err
	if n == 1 {
		p[0] = rres.b
	}
	if err == nil {
		err = io.EOF
	}
	return
}

var nopCloserType = reflect.TypeOf(io.NopCloser(nil))

// isknownMemoryReader报告r是否为已知类型，而不是
// block on Read。它的调用者将此作为可选优化来发送更少的TCP数据包。
func isKnownInMemoryReader(r io.Reader) bool {
	switch r.(type) {
	case *bytes.Reader, *bytes.Buffer, *strings.Reader:
		return true
	}
	if reflect.TypeOf(r) == nopCloserType {
		return isKnownInMemoryReader(reflect.ValueOf(r).Field(0).Interface().(io.Reader))
	}
	if r, ok := r.(*readTrackingBody); ok {
		return isKnownInMemoryReader(r.ReadCloser)
	}
	return false
}

// bufioFlushWriter是一个io。刷新所有内容的Writer wrapper在其包装的Writer上写入
// 如果是*bufio。作家
type bufioFlushWriter struct{ w io.Writer }

func (fw bufioFlushWriter) Write(p []byte) (n int, err error) {
	n, err = fw.w.Write(p)
	if bw, ok := fw.w.(*bufio.Writer); n > 0 && ok {
		ferr := bw.Flush()
		if ferr != nil && err == nil {
			err = ferr
		}
	}
	return
}
